home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / netdevice.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  29KB  |  939 lines
  1. /*
  2.  * INET        An implementation of the TCP/IP protocol suite for the LINUX
  3.  *        operating system.  INET is implemented using the  BSD Socket
  4.  *        interface as the means of communication with the user level.
  5.  *
  6.  *        Definitions for the Interfaces handler.
  7.  *
  8.  * Version:    @(#)dev.h    1.0.10    08/12/93
  9.  *
  10.  * Authors:    Ross Biro, <bir7@leland.Stanford.Edu>
  11.  *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12.  *        Corey Minyard <wf-rch!minyard@relay.EU.net>
  13.  *        Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  14.  *        Alan Cox, <Alan.Cox@linux.org>
  15.  *        Bjorn Ekwall. <bj0rn@blox.se>
  16.  *              Pekka Riikonen <priikone@poseidon.pspt.fi>
  17.  *
  18.  *        This program is free software; you can redistribute it and/or
  19.  *        modify it under the terms of the GNU General Public License
  20.  *        as published by the Free Software Foundation; either version
  21.  *        2 of the License, or (at your option) any later version.
  22.  *
  23.  *        Moved to /usr/include/linux for NET3
  24.  */
  25. #ifndef _LINUX_NETDEVICE_H
  26. #define _LINUX_NETDEVICE_H
  27.  
  28. #include <linux/if.h>
  29. #include <linux/if_ether.h>
  30. #include <linux/if_packet.h>
  31.  
  32. #ifdef __KERNEL__
  33. #include <asm/atomic.h>
  34. #include <asm/cache.h>
  35. #include <asm/byteorder.h>
  36.  
  37. #include <linux/config.h>
  38. #include <linux/device.h>
  39. #include <linux/percpu.h>
  40.  
  41. struct divert_blk;
  42. struct vlan_group;
  43. struct ethtool_ops;
  44.  
  45.                     /* source back-compat hooks */
  46. #define SET_ETHTOOL_OPS(netdev,ops) \
  47.     ( (netdev)->ethtool_ops = (ops) )
  48.  
  49. #define HAVE_ALLOC_NETDEV        /* feature macro: alloc_xxxdev
  50.                        functions are available. */
  51. #define HAVE_FREE_NETDEV        /* free_netdev() */
  52. #define HAVE_NETDEV_PRIV        /* netdev_priv() */
  53.  
  54. #define NET_XMIT_SUCCESS    0
  55. #define NET_XMIT_DROP        1    /* skb dropped            */
  56. #define NET_XMIT_CN        2    /* congestion notification    */
  57. #define NET_XMIT_POLICED    3    /* skb is shot by police    */
  58. #define NET_XMIT_BYPASS        4    /* packet does not leave via dequeue;
  59.                        (TC use only - dev_queue_xmit
  60.                        returns this as NET_XMIT_SUCCESS) */
  61.  
  62. /* Backlog congestion levels */
  63. #define NET_RX_SUCCESS        0   /* keep 'em coming, baby */
  64. #define NET_RX_DROP        1  /* packet dropped */
  65. #define NET_RX_CN_LOW        2   /* storm alert, just in case */
  66. #define NET_RX_CN_MOD        3   /* Storm on its way! */
  67. #define NET_RX_CN_HIGH        4   /* The storm is here */
  68. #define NET_RX_BAD        5  /* packet dropped due to kernel error */
  69.  
  70. #define net_xmit_errno(e)    ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  71.  
  72. #endif
  73.  
  74. #define MAX_ADDR_LEN    32        /* Largest hardware address length */
  75.  
  76. /* Driver transmit return codes */
  77. #define NETDEV_TX_OK 0        /* driver took care of packet */
  78. #define NETDEV_TX_BUSY 1    /* driver tx path was busy*/
  79. #define NETDEV_TX_LOCKED -1    /* driver tx lock was already taken */
  80.  
  81. /*
  82.  *    Compute the worst case header length according to the protocols
  83.  *    used.
  84.  */
  85.  
  86. #if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
  87. #define LL_MAX_HEADER    32
  88. #else
  89. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  90. #define LL_MAX_HEADER    96
  91. #else
  92. #define LL_MAX_HEADER    48
  93. #endif
  94. #endif
  95.  
  96. #if !defined(CONFIG_NET_IPIP) && \
  97.     !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
  98. #define MAX_HEADER LL_MAX_HEADER
  99. #else
  100. #define MAX_HEADER (LL_MAX_HEADER + 48)
  101. #endif
  102.  
  103. /*
  104.  *    Network device statistics. Akin to the 2.0 ether stats but
  105.  *    with byte counters.
  106.  */
  107.  
  108. struct net_device_stats
  109. {
  110.     unsigned long    rx_packets;        /* total packets received    */
  111.     unsigned long    tx_packets;        /* total packets transmitted    */
  112.     unsigned long    rx_bytes;        /* total bytes received     */
  113.     unsigned long    tx_bytes;        /* total bytes transmitted    */
  114.     unsigned long    rx_errors;        /* bad packets received        */
  115.     unsigned long    tx_errors;        /* packet transmit problems    */
  116.     unsigned long    rx_dropped;        /* no space in linux buffers    */
  117.     unsigned long    tx_dropped;        /* no space available in linux    */
  118.     unsigned long    multicast;        /* multicast packets received    */
  119.     unsigned long    collisions;
  120.  
  121.     /* detailed rx_errors: */
  122.     unsigned long    rx_length_errors;
  123.     unsigned long    rx_over_errors;        /* receiver ring buff overflow    */
  124.     unsigned long    rx_crc_errors;        /* recved pkt with crc error    */
  125.     unsigned long    rx_frame_errors;    /* recv'd frame alignment error */
  126.     unsigned long    rx_fifo_errors;        /* recv'r fifo overrun        */
  127.     unsigned long    rx_missed_errors;    /* receiver missed packet    */
  128.  
  129.     /* detailed tx_errors */
  130.     unsigned long    tx_aborted_errors;
  131.     unsigned long    tx_carrier_errors;
  132.     unsigned long    tx_fifo_errors;
  133.     unsigned long    tx_heartbeat_errors;
  134.     unsigned long    tx_window_errors;
  135.     
  136.     /* for cslip etc */
  137.     unsigned long    rx_compressed;
  138.     unsigned long    tx_compressed;
  139. };
  140.  
  141.  
  142. /* Media selection options. */
  143. enum {
  144.         IF_PORT_UNKNOWN = 0,
  145.         IF_PORT_10BASE2,
  146.         IF_PORT_10BASET,
  147.         IF_PORT_AUI,
  148.         IF_PORT_100BASET,
  149.         IF_PORT_100BASETX,
  150.         IF_PORT_100BASEFX
  151. };
  152.  
  153. #ifdef __KERNEL__
  154.  
  155. #include <linux/cache.h>
  156. #include <linux/skbuff.h>
  157.  
  158. struct neighbour;
  159. struct neigh_parms;
  160. struct sk_buff;
  161.  
  162. struct netif_rx_stats
  163. {
  164.     unsigned total;
  165.     unsigned dropped;
  166.     unsigned time_squeeze;
  167.     unsigned throttled;
  168.     unsigned fastroute_hit;
  169.     unsigned fastroute_success;
  170.     unsigned fastroute_defer;
  171.     unsigned fastroute_deferred_out;
  172.     unsigned fastroute_latency_reduction;
  173.     unsigned cpu_collision;
  174. };
  175.  
  176. DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
  177.  
  178.  
  179. /*
  180.  *    We tag multicasts with these structures.
  181.  */
  182.  
  183. struct dev_mc_list
  184. {    
  185.     struct dev_mc_list    *next;
  186.     __u8            dmi_addr[MAX_ADDR_LEN];
  187.     unsigned char        dmi_addrlen;
  188.     int            dmi_users;
  189.     int            dmi_gusers;
  190. };
  191.  
  192. struct hh_cache
  193. {
  194.     struct hh_cache *hh_next;    /* Next entry                 */
  195.     atomic_t    hh_refcnt;    /* number of users                   */
  196.     unsigned short  hh_type;    /* protocol identifier, f.e ETH_P_IP
  197.                                          *  NOTE:  For VLANs, this will be the
  198.                                          *  encapuslated type. --BLG
  199.                                          */
  200.     int        hh_len;        /* length of header */
  201.     int        (*hh_output)(struct sk_buff *skb);
  202.     rwlock_t    hh_lock;
  203.  
  204.     /* cached hardware header; allow for machine alignment needs.        */
  205. #define HH_DATA_MOD    16
  206. #define HH_DATA_OFF(__len) \
  207.     (HH_DATA_MOD - ((__len) & (HH_DATA_MOD - 1)))
  208. #define HH_DATA_ALIGN(__len) \
  209.     (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  210.     unsigned long    hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  211. };
  212.  
  213. /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  214.  * Alternative is:
  215.  *   dev->hard_header_len ? (dev->hard_header_len +
  216.  *                           (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  217.  *
  218.  * We could use other alignment values, but we must maintain the
  219.  * relationship HH alignment <= LL alignment.
  220.  */
  221. #define LL_RESERVED_SPACE(dev) \
  222.     (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  223. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  224.     ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  225.  
  226. /* These flag bits are private to the generic network queueing
  227.  * layer, they may not be explicitly referenced by any other
  228.  * code.
  229.  */
  230.  
  231. enum netdev_state_t
  232. {
  233.     __LINK_STATE_XOFF=0,
  234.     __LINK_STATE_START,
  235.     __LINK_STATE_PRESENT,
  236.     __LINK_STATE_SCHED,
  237.     __LINK_STATE_NOCARRIER,
  238.     __LINK_STATE_RX_SCHED,
  239.     __LINK_STATE_LINKWATCH_PENDING
  240. };
  241.  
  242.  
  243. /*
  244.  * This structure holds at boot time configured netdevice settings. They
  245.  * are then used in the device probing. 
  246.  */
  247. struct netdev_boot_setup {
  248.     char name[IFNAMSIZ];
  249.     struct ifmap map;
  250. };
  251. #define NETDEV_BOOT_SETUP_MAX 8
  252.  
  253.  
  254. /*
  255.  *    The DEVICE structure.
  256.  *    Actually, this whole structure is a big mistake.  It mixes I/O
  257.  *    data with strictly "high-level" data, and it has to know about
  258.  *    almost every data structure used in the INET module.
  259.  *
  260.  *    FIXME: cleanup struct net_device such that network protocol info
  261.  *    moves out.
  262.  */
  263.  
  264. struct net_device
  265. {
  266.  
  267.     /*
  268.      * This is the first field of the "visible" part of this structure
  269.      * (i.e. as seen by users in the "Space.c" file).  It is the name
  270.      * the interface.
  271.      */
  272.     char            name[IFNAMSIZ];
  273.  
  274.     /*
  275.      *    I/O specific fields
  276.      *    FIXME: Merge these and struct ifmap into one
  277.      */
  278.     unsigned long        mem_end;    /* shared mem end    */
  279.     unsigned long        mem_start;    /* shared mem start    */
  280.     unsigned long        base_addr;    /* device I/O address    */
  281.     unsigned int        irq;        /* device IRQ number    */
  282.  
  283.     /*
  284.      *    Some hardware also needs these fields, but they are not
  285.      *    part of the usual set specified in Space.c.
  286.      */
  287.  
  288.     unsigned char        if_port;    /* Selectable AUI, TP,..*/
  289.     unsigned char        dma;        /* DMA channel        */
  290.  
  291.     unsigned long        state;
  292.  
  293.     struct net_device    *next;
  294.     
  295.     /* The device initialization function. Called only once. */
  296.     int            (*init)(struct net_device *dev);
  297.  
  298.     /* ------- Fields preinitialized in Space.c finish here ------- */
  299.  
  300.     struct net_device    *next_sched;
  301.  
  302.     /* Interface index. Unique device identifier    */
  303.     int            ifindex;
  304.     int            iflink;
  305.  
  306.  
  307.     struct net_device_stats* (*get_stats)(struct net_device *dev);
  308.     struct iw_statistics*    (*get_wireless_stats)(struct net_device *dev);
  309.  
  310.     /* List of functions to handle Wireless Extensions (instead of ioctl).
  311.      * See <net/iw_handler.h> for details. Jean II */
  312.     const struct iw_handler_def *    wireless_handlers;
  313.     /* Instance data managed by the core of Wireless Extensions. */
  314.     struct iw_public_data *    wireless_data;
  315.  
  316.     struct ethtool_ops *ethtool_ops;
  317.  
  318.     /*
  319.      * This marks the end of the "visible" part of the structure. All
  320.      * fields hereafter are internal to the system, and may change at
  321.      * will (read: may be cleaned up at will).
  322.      */
  323.  
  324.     /* These may be needed for future network-power-down code. */
  325.     unsigned long        trans_start;    /* Time (in jiffies) of last Tx    */
  326.     unsigned long        last_rx;    /* Time of last Rx    */
  327.  
  328.     unsigned short        flags;    /* interface flags (a la BSD)    */
  329.     unsigned short        gflags;
  330.         unsigned short          priv_flags; /* Like 'flags' but invisible to userspace. */
  331.         unsigned short          unused_alignment_fixer; /* Because we need priv_flags,
  332.                                                          * and we want to be 32-bit aligned.
  333.                                                          */
  334.  
  335.     unsigned        mtu;    /* interface MTU value        */
  336.     unsigned short        type;    /* interface hardware type    */
  337.     unsigned short        hard_header_len;    /* hardware hdr length    */
  338.     void            *priv;    /* pointer to private data    */
  339.  
  340.     struct net_device    *master; /* Pointer to master device of a group,
  341.                       * which this device is member of.
  342.                       */
  343.  
  344.     /* Interface address info. */
  345.     unsigned char        broadcast[MAX_ADDR_LEN];    /* hw bcast add    */
  346.     unsigned char        dev_addr[MAX_ADDR_LEN];    /* hw address    */
  347.     unsigned char        addr_len;    /* hardware address length    */
  348.     unsigned short          dev_id;        /* for shared network cards */
  349.  
  350.     struct dev_mc_list    *mc_list;    /* Multicast mac addresses    */
  351.     int            mc_count;    /* Number of installed mcasts    */
  352.     int            promiscuity;
  353.     int            allmulti;
  354.  
  355.     int            watchdog_timeo;
  356.     struct timer_list    watchdog_timer;
  357.  
  358.     /* Protocol specific pointers */
  359.     
  360.     void             *atalk_ptr;    /* AppleTalk link     */
  361.     void            *ip_ptr;    /* IPv4 specific data    */  
  362.     void                    *dn_ptr;        /* DECnet specific data */
  363.     void                    *ip6_ptr;       /* IPv6 specific data */
  364.     void            *ec_ptr;    /* Econet specific data    */
  365.     void            *ax25_ptr;    /* AX.25 specific data */
  366.  
  367.     struct list_head    poll_list;    /* Link to poll list    */
  368.     int            quota;
  369.     int            weight;
  370.  
  371.     struct Qdisc        *qdisc;
  372.     struct Qdisc        *qdisc_sleeping;
  373.     struct Qdisc        *qdisc_ingress;
  374.     struct list_head    qdisc_list;
  375.     unsigned long        tx_queue_len;    /* Max frames per queue allowed */
  376.  
  377.     /* ingress path synchronizer */
  378.     spinlock_t        ingress_lock;
  379.     /* hard_start_xmit synchronizer */
  380.     spinlock_t        xmit_lock;
  381.     /* cpu id of processor entered to hard_start_xmit or -1,
  382.        if nobody entered there.
  383.      */
  384.     int            xmit_lock_owner;
  385.     /* device queue lock */
  386.     spinlock_t        queue_lock;
  387.     /* Number of references to this device */
  388.     atomic_t        refcnt;
  389.     /* delayed register/unregister */
  390.     struct list_head    todo_list;
  391.     /* device name hash chain */
  392.     struct hlist_node    name_hlist;
  393.     /* device index hash chain */
  394.     struct hlist_node    index_hlist;
  395.  
  396.     /* register/unregister state machine */
  397.     enum { NETREG_UNINITIALIZED=0,
  398.            NETREG_REGISTERING,    /* called register_netdevice */
  399.            NETREG_REGISTERED,    /* completed register todo */
  400.            NETREG_UNREGISTERING,    /* called unregister_netdevice */
  401.            NETREG_UNREGISTERED,    /* completed unregister todo */
  402.            NETREG_RELEASED,        /* called free_netdev */
  403.     } reg_state;
  404.  
  405.     /* Net device features */
  406.     int            features;
  407. #define NETIF_F_SG        1    /* Scatter/gather IO. */
  408. #define NETIF_F_IP_CSUM        2    /* Can checksum only TCP/UDP over IPv4. */
  409. #define NETIF_F_NO_CSUM        4    /* Does not require checksum. F.e. loopack. */
  410. #define NETIF_F_HW_CSUM        8    /* Can checksum all the packets. */
  411. #define NETIF_F_HIGHDMA        32    /* Can DMA to high memory. */
  412. #define NETIF_F_FRAGLIST    64    /* Scatter/gather IO. */
  413. #define NETIF_F_HW_VLAN_TX    128    /* Transmit VLAN hw acceleration */
  414. #define NETIF_F_HW_VLAN_RX    256    /* Receive VLAN hw acceleration */
  415. #define NETIF_F_HW_VLAN_FILTER    512    /* Receive filtering on VLAN */
  416. #define NETIF_F_VLAN_CHALLENGED    1024    /* Device cannot handle VLAN packets */
  417. #define NETIF_F_TSO        2048    /* Can offload TCP/IP segmentation */
  418. #define NETIF_F_LLTX        4096    /* LockLess TX */
  419.  
  420.     /* Called after device is detached from network. */
  421.     void            (*uninit)(struct net_device *dev);
  422.     /* Called after last user reference disappears. */
  423.     void            (*destructor)(struct net_device *dev);
  424.  
  425.     /* Pointers to interface service routines.    */
  426.     int            (*open)(struct net_device *dev);
  427.     int            (*stop)(struct net_device *dev);
  428.     int            (*hard_start_xmit) (struct sk_buff *skb,
  429.                             struct net_device *dev);
  430. #define HAVE_NETDEV_POLL
  431.     int            (*poll) (struct net_device *dev, int *quota);
  432.     int            (*hard_header) (struct sk_buff *skb,
  433.                         struct net_device *dev,
  434.                         unsigned short type,
  435.                         void *daddr,
  436.                         void *saddr,
  437.                         unsigned len);
  438.     int            (*rebuild_header)(struct sk_buff *skb);
  439. #define HAVE_MULTICAST             
  440.     void            (*set_multicast_list)(struct net_device *dev);
  441. #define HAVE_SET_MAC_ADDR           
  442.     int            (*set_mac_address)(struct net_device *dev,
  443.                            void *addr);
  444. #define HAVE_PRIVATE_IOCTL
  445.     int            (*do_ioctl)(struct net_device *dev,
  446.                         struct ifreq *ifr, int cmd);
  447. #define HAVE_SET_CONFIG
  448.     int            (*set_config)(struct net_device *dev,
  449.                           struct ifmap *map);
  450. #define HAVE_HEADER_CACHE
  451.     int            (*hard_header_cache)(struct neighbour *neigh,
  452.                              struct hh_cache *hh);
  453.     void            (*header_cache_update)(struct hh_cache *hh,
  454.                                struct net_device *dev,
  455.                                unsigned char *  haddr);
  456. #define HAVE_CHANGE_MTU
  457.     int            (*change_mtu)(struct net_device *dev, int new_mtu);
  458.  
  459. #define HAVE_TX_TIMEOUT
  460.     void            (*tx_timeout) (struct net_device *dev);
  461.  
  462.     void            (*vlan_rx_register)(struct net_device *dev,
  463.                             struct vlan_group *grp);
  464.     void            (*vlan_rx_add_vid)(struct net_device *dev,
  465.                            unsigned short vid);
  466.     void            (*vlan_rx_kill_vid)(struct net_device *dev,
  467.                             unsigned short vid);
  468.  
  469.     int            (*hard_header_parse)(struct sk_buff *skb,
  470.                              unsigned char *haddr);
  471.     int            (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
  472.     int            (*accept_fastpath)(struct net_device *, struct dst_entry*);
  473. #ifdef CONFIG_NETPOLL
  474.     int            netpoll_rx;
  475. #endif
  476. #ifdef CONFIG_NET_POLL_CONTROLLER
  477.     void                    (*poll_controller)(struct net_device *dev);
  478. #endif
  479.  
  480.     /* bridge stuff */
  481.     struct net_bridge_port    *br_port;
  482.  
  483. #ifdef CONFIG_NET_DIVERT
  484.     /* this will get initialized at each interface type init routine */
  485.     struct divert_blk    *divert;
  486. #endif /* CONFIG_NET_DIVERT */
  487.  
  488.     /* class/net/name entry */
  489.     struct class_device    class_dev;
  490.     /* how much padding had been added by alloc_netdev() */
  491.     int padded;
  492. };
  493.  
  494. #define    NETDEV_ALIGN        32
  495. #define    NETDEV_ALIGN_CONST    (NETDEV_ALIGN - 1)
  496.  
  497. static inline void *netdev_priv(struct net_device *dev)
  498. {
  499.     return (char *)dev + ((sizeof(struct net_device)
  500.                     + NETDEV_ALIGN_CONST)
  501.                 & ~NETDEV_ALIGN_CONST);
  502. }
  503.  
  504. #define SET_MODULE_OWNER(dev) do { } while (0)
  505. /* Set the sysfs physical device reference for the network logical device
  506.  * if set prior to registration will cause a symlink during initialization.
  507.  */
  508. #define SET_NETDEV_DEV(net, pdev)    ((net)->class_dev.dev = (pdev))
  509.  
  510. struct packet_type {
  511.     unsigned short        type;    /* This is really htons(ether_type).    */
  512.     struct net_device        *dev;    /* NULL is wildcarded here        */
  513.     int            (*func) (struct sk_buff *, struct net_device *,
  514.                      struct packet_type *);
  515.     void            *af_packet_priv;
  516.     struct list_head    list;
  517. };
  518.  
  519. #include <linux/interrupt.h>
  520. #include <linux/notifier.h>
  521.  
  522. extern struct net_device        loopback_dev;        /* The loopback */
  523. extern struct net_device        *dev_base;        /* All devices */
  524. extern rwlock_t                dev_base_lock;        /* Device list lock */
  525.  
  526. extern int             netdev_boot_setup_check(struct net_device *dev);
  527. extern unsigned long        netdev_boot_base(const char *prefix, int unit);
  528. extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
  529. extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
  530. extern void        dev_add_pack(struct packet_type *pt);
  531. extern void        dev_remove_pack(struct packet_type *pt);
  532. extern void        __dev_remove_pack(struct packet_type *pt);
  533.  
  534. extern struct net_device    *dev_get_by_flags(unsigned short flags,
  535.                           unsigned short mask);
  536. extern struct net_device    *dev_get_by_name(const char *name);
  537. extern struct net_device    *__dev_get_by_name(const char *name);
  538. extern int        dev_alloc_name(struct net_device *dev, const char *name);
  539. extern int        dev_open(struct net_device *dev);
  540. extern int        dev_close(struct net_device *dev);
  541. extern int        dev_queue_xmit(struct sk_buff *skb);
  542. extern int        register_netdevice(struct net_device *dev);
  543. extern int        unregister_netdevice(struct net_device *dev);
  544. extern void        free_netdev(struct net_device *dev);
  545. extern void        synchronize_net(void);
  546. extern int         register_netdevice_notifier(struct notifier_block *nb);
  547. extern int        unregister_netdevice_notifier(struct notifier_block *nb);
  548. extern int        call_netdevice_notifiers(unsigned long val, void *v);
  549. extern struct net_device    *dev_get_by_index(int ifindex);
  550. extern struct net_device    *__dev_get_by_index(int ifindex);
  551. extern int        dev_restart(struct net_device *dev);
  552. #ifdef CONFIG_NETPOLL_TRAP
  553. extern int        netpoll_trap(void);
  554. #endif
  555.  
  556. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  557. extern int        register_gifconf(unsigned int family, gifconf_func_t * gifconf);
  558. static inline int unregister_gifconf(unsigned int family)
  559. {
  560.     return register_gifconf(family, NULL);
  561. }
  562.  
  563. /*
  564.  * Incoming packets are placed on per-cpu queues so that
  565.  * no locking is needed.
  566.  */
  567.  
  568. struct softnet_data
  569. {
  570.     int            throttle;
  571.     int            cng_level;
  572.     int            avg_blog;
  573.     struct sk_buff_head    input_pkt_queue;
  574.     struct list_head    poll_list;
  575.     struct net_device    *output_queue;
  576.     struct sk_buff        *completion_queue;
  577.  
  578.     struct net_device    backlog_dev;    /* Sorry. 8) */
  579. };
  580.  
  581. DECLARE_PER_CPU(struct softnet_data,softnet_data);
  582.  
  583. #define HAVE_NETIF_QUEUE
  584.  
  585. static inline void __netif_schedule(struct net_device *dev)
  586. {
  587.     if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
  588.         unsigned long flags;
  589.         struct softnet_data *sd;
  590.  
  591.         local_irq_save(flags);
  592.         sd = &__get_cpu_var(softnet_data);
  593.         dev->next_sched = sd->output_queue;
  594.         sd->output_queue = dev;
  595.         raise_softirq_irqoff(NET_TX_SOFTIRQ);
  596.         local_irq_restore(flags);
  597.     }
  598. }
  599.  
  600. static inline void netif_schedule(struct net_device *dev)
  601. {
  602.     if (!test_bit(__LINK_STATE_XOFF, &dev->state))
  603.         __netif_schedule(dev);
  604. }
  605.  
  606. static inline void netif_start_queue(struct net_device *dev)
  607. {
  608.     clear_bit(__LINK_STATE_XOFF, &dev->state);
  609. }
  610.  
  611. static inline void netif_wake_queue(struct net_device *dev)
  612. {
  613. #ifdef CONFIG_NETPOLL_TRAP
  614.     if (netpoll_trap())
  615.         return;
  616. #endif
  617.     if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
  618.         __netif_schedule(dev);
  619. }
  620.  
  621. static inline void netif_stop_queue(struct net_device *dev)
  622. {
  623. #ifdef CONFIG_NETPOLL_TRAP
  624.     if (netpoll_trap())
  625.         return;
  626. #endif
  627.     set_bit(__LINK_STATE_XOFF, &dev->state);
  628. }
  629.  
  630. static inline int netif_queue_stopped(const struct net_device *dev)
  631. {
  632.     return test_bit(__LINK_STATE_XOFF, &dev->state);
  633. }
  634.  
  635. static inline int netif_running(const struct net_device *dev)
  636. {
  637.     return test_bit(__LINK_STATE_START, &dev->state);
  638. }
  639.  
  640.  
  641. /* Use this variant when it is known for sure that it
  642.  * is executing from interrupt context.
  643.  */
  644. static inline void dev_kfree_skb_irq(struct sk_buff *skb)
  645. {
  646.     if (atomic_dec_and_test(&skb->users)) {
  647.         struct softnet_data *sd;
  648.         unsigned long flags;
  649.  
  650.         local_irq_save(flags);
  651.         sd = &__get_cpu_var(softnet_data);
  652.         skb->next = sd->completion_queue;
  653.         sd->completion_queue = skb;
  654.         raise_softirq_irqoff(NET_TX_SOFTIRQ);
  655.         local_irq_restore(flags);
  656.     }
  657. }
  658.  
  659. /* Use this variant in places where it could be invoked
  660.  * either from interrupt or non-interrupt context.
  661.  */
  662. static inline void dev_kfree_skb_any(struct sk_buff *skb)
  663. {
  664.     if (in_irq() || irqs_disabled())
  665.         dev_kfree_skb_irq(skb);
  666.     else
  667.         dev_kfree_skb(skb);
  668. }
  669.  
  670. #define HAVE_NETIF_RX 1
  671. extern int        netif_rx(struct sk_buff *skb);
  672. extern int        netif_rx_ni(struct sk_buff *skb);
  673. #define HAVE_NETIF_RECEIVE_SKB 1
  674. extern int        netif_receive_skb(struct sk_buff *skb);
  675. extern int        dev_ioctl(unsigned int cmd, void __user *);
  676. extern int        dev_ethtool(struct ifreq *);
  677. extern unsigned        dev_get_flags(const struct net_device *);
  678. extern int        dev_change_flags(struct net_device *, unsigned);
  679. extern int        dev_change_name(struct net_device *, char *);
  680. extern int        dev_set_mtu(struct net_device *, int);
  681. extern void        dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
  682.  
  683. extern void        dev_init(void);
  684.  
  685. extern int        netdev_nit;
  686.  
  687. /* Called by rtnetlink.c:rtnl_unlock() */
  688. extern void netdev_run_todo(void);
  689.  
  690. static inline void dev_put(struct net_device *dev)
  691. {
  692.     atomic_dec(&dev->refcnt);
  693. }
  694.  
  695. #define __dev_put(dev) atomic_dec(&(dev)->refcnt)
  696. #define dev_hold(dev) atomic_inc(&(dev)->refcnt)
  697.  
  698. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  699.  * and _off may be called from IRQ context, but it is caller
  700.  * who is responsible for serialization of these calls.
  701.  */
  702.  
  703. extern void linkwatch_fire_event(struct net_device *dev);
  704.  
  705. static inline int netif_carrier_ok(const struct net_device *dev)
  706. {
  707.     return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  708. }
  709.  
  710. extern void __netdev_watchdog_up(struct net_device *dev);
  711.  
  712. static inline void netif_carrier_on(struct net_device *dev)
  713. {
  714.     if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state))
  715.         linkwatch_fire_event(dev);
  716.     if (netif_running(dev))
  717.         __netdev_watchdog_up(dev);
  718. }
  719.  
  720. static inline void netif_carrier_off(struct net_device *dev)
  721. {
  722.     if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state))
  723.         linkwatch_fire_event(dev);
  724. }
  725.  
  726. /* Hot-plugging. */
  727. static inline int netif_device_present(struct net_device *dev)
  728. {
  729.     return test_bit(__LINK_STATE_PRESENT, &dev->state);
  730. }
  731.  
  732. static inline void netif_device_detach(struct net_device *dev)
  733. {
  734.     if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
  735.         netif_running(dev)) {
  736.         netif_stop_queue(dev);
  737.     }
  738. }
  739.  
  740. static inline void netif_device_attach(struct net_device *dev)
  741. {
  742.     if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
  743.         netif_running(dev)) {
  744.         netif_wake_queue(dev);
  745.          __netdev_watchdog_up(dev);
  746.     }
  747. }
  748.  
  749. /*
  750.  * Network interface message level settings
  751.  */
  752. #define HAVE_NETIF_MSG 1
  753.  
  754. enum {
  755.     NETIF_MSG_DRV        = 0x0001,
  756.     NETIF_MSG_PROBE        = 0x0002,
  757.     NETIF_MSG_LINK        = 0x0004,
  758.     NETIF_MSG_TIMER        = 0x0008,
  759.     NETIF_MSG_IFDOWN    = 0x0010,
  760.     NETIF_MSG_IFUP        = 0x0020,
  761.     NETIF_MSG_RX_ERR    = 0x0040,
  762.     NETIF_MSG_TX_ERR    = 0x0080,
  763.     NETIF_MSG_TX_QUEUED    = 0x0100,
  764.     NETIF_MSG_INTR        = 0x0200,
  765.     NETIF_MSG_TX_DONE    = 0x0400,
  766.     NETIF_MSG_RX_STATUS    = 0x0800,
  767.     NETIF_MSG_PKTDATA    = 0x1000,
  768.     NETIF_MSG_HW        = 0x2000,
  769.     NETIF_MSG_WOL        = 0x4000,
  770. };
  771.  
  772. #define netif_msg_drv(p)    ((p)->msg_enable & NETIF_MSG_DRV)
  773. #define netif_msg_probe(p)    ((p)->msg_enable & NETIF_MSG_PROBE)
  774. #define netif_msg_link(p)    ((p)->msg_enable & NETIF_MSG_LINK)
  775. #define netif_msg_timer(p)    ((p)->msg_enable & NETIF_MSG_TIMER)
  776. #define netif_msg_ifdown(p)    ((p)->msg_enable & NETIF_MSG_IFDOWN)
  777. #define netif_msg_ifup(p)    ((p)->msg_enable & NETIF_MSG_IFUP)
  778. #define netif_msg_rx_err(p)    ((p)->msg_enable & NETIF_MSG_RX_ERR)
  779. #define netif_msg_tx_err(p)    ((p)->msg_enable & NETIF_MSG_TX_ERR)
  780. #define netif_msg_tx_queued(p)    ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  781. #define netif_msg_intr(p)    ((p)->msg_enable & NETIF_MSG_INTR)
  782. #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
  783. #define netif_msg_rx_status(p)    ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  784. #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
  785. #define netif_msg_hw(p)        ((p)->msg_enable & NETIF_MSG_HW)
  786. #define netif_msg_wol(p)    ((p)->msg_enable & NETIF_MSG_WOL)
  787.  
  788. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  789. {
  790.     /* use default */
  791.     if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  792.         return default_msg_enable_bits;
  793.     if (debug_value == 0)    /* no output */
  794.         return 0;
  795.     /* set low N bits */
  796.     return (1 << debug_value) - 1;
  797. }
  798.  
  799. /* Schedule rx intr now? */
  800.  
  801. static inline int netif_rx_schedule_prep(struct net_device *dev)
  802. {
  803.     return netif_running(dev) &&
  804.         !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
  805. }
  806.  
  807. /* Add interface to tail of rx poll list. This assumes that _prep has
  808.  * already been called and returned 1.
  809.  */
  810.  
  811. static inline void __netif_rx_schedule(struct net_device *dev)
  812. {
  813.     unsigned long flags;
  814.  
  815.     local_irq_save(flags);
  816.     dev_hold(dev);
  817.     list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
  818.     if (dev->quota < 0)
  819.         dev->quota += dev->weight;
  820.     else
  821.         dev->quota = dev->weight;
  822.     __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  823.     local_irq_restore(flags);
  824. }
  825.  
  826. /* Try to reschedule poll. Called by irq handler. */
  827.  
  828. static inline void netif_rx_schedule(struct net_device *dev)
  829. {
  830.     if (netif_rx_schedule_prep(dev))
  831.         __netif_rx_schedule(dev);
  832. }
  833.  
  834. /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
  835.  * Do not inline this?
  836.  */
  837. static inline int netif_rx_reschedule(struct net_device *dev, int undo)
  838. {
  839.     if (netif_rx_schedule_prep(dev)) {
  840.         unsigned long flags;
  841.  
  842.         dev->quota += undo;
  843.  
  844.         local_irq_save(flags);
  845.         list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
  846.         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  847.         local_irq_restore(flags);
  848.         return 1;
  849.     }
  850.     return 0;
  851. }
  852.  
  853. /* Remove interface from poll list: it must be in the poll list
  854.  * on current cpu. This primitive is called by dev->poll(), when
  855.  * it completes the work. The device cannot be out of poll list at this
  856.  * moment, it is BUG().
  857.  */
  858. static inline void netif_rx_complete(struct net_device *dev)
  859. {
  860.     unsigned long flags;
  861.  
  862.     local_irq_save(flags);
  863.     BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
  864.     list_del(&dev->poll_list);
  865.     smp_mb__before_clear_bit();
  866.     clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  867.     local_irq_restore(flags);
  868. }
  869.  
  870. static inline void netif_poll_disable(struct net_device *dev)
  871. {
  872.     while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
  873.         /* No hurry. */
  874.         current->state = TASK_INTERRUPTIBLE;
  875.         schedule_timeout(1);
  876.     }
  877. }
  878.  
  879. static inline void netif_poll_enable(struct net_device *dev)
  880. {
  881.     clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  882. }
  883.  
  884. /* same as netif_rx_complete, except that local_irq_save(flags)
  885.  * has already been issued
  886.  */
  887. static inline void __netif_rx_complete(struct net_device *dev)
  888. {
  889.     BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
  890.     list_del(&dev->poll_list);
  891.     smp_mb__before_clear_bit();
  892.     clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  893. }
  894.  
  895. static inline void netif_tx_disable(struct net_device *dev)
  896. {
  897.     spin_lock_bh(&dev->xmit_lock);
  898.     netif_stop_queue(dev);
  899.     spin_unlock_bh(&dev->xmit_lock);
  900. }
  901.  
  902. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  903.  
  904. extern void        ether_setup(struct net_device *dev);
  905.  
  906. /* Support for loadable net-drivers */
  907. extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
  908.                        void (*setup)(struct net_device *));
  909. extern int        register_netdev(struct net_device *dev);
  910. extern void        unregister_netdev(struct net_device *dev);
  911. /* Functions used for multicast support */
  912. extern void        dev_mc_upload(struct net_device *dev);
  913. extern int         dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
  914. extern int        dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
  915. extern void        dev_mc_discard(struct net_device *dev);
  916. extern void        dev_set_promiscuity(struct net_device *dev, int inc);
  917. extern void        dev_set_allmulti(struct net_device *dev, int inc);
  918. extern void        netdev_state_change(struct net_device *dev);
  919. /* Load a device via the kmod */
  920. extern void        dev_load(const char *name);
  921. extern void        dev_mcast_init(void);
  922. extern int        netdev_max_backlog;
  923. extern int        weight_p;
  924. extern unsigned long    netdev_fc_xoff;
  925. extern atomic_t netdev_dropping;
  926. extern int        netdev_set_master(struct net_device *dev, struct net_device *master);
  927. extern int skb_checksum_help(struct sk_buff *skb, int inward);
  928. /* rx skb timestamps */
  929. extern void        net_enable_timestamp(void);
  930. extern void        net_disable_timestamp(void);
  931.  
  932. #ifdef CONFIG_SYSCTL
  933. extern char *net_sysctl_strdup(const char *s);
  934. #endif
  935.  
  936. #endif /* __KERNEL__ */
  937.  
  938. #endif    /* _LINUX_DEV_H */
  939.